home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume6 / xnetld / patch1 next >
Encoding:
Text File  |  1990-03-20  |  47.6 KB  |  1,698 lines
  1. Path: uunet!tut.cis.ohio-state.edu!zaphod.mps.ohio-state.edu!brutus.cs.uiuc.edu!apple!sun-barr!newstop!sun!icsib12.Berkeley.EDU
  2. From: stolcke@icsib12.Berkeley.EDU (Andreas Stolcke)
  3. Newsgroups: comp.sources.x
  4. Subject: v06i038: xnetload, Patch1
  5. Message-ID: <133251@sun.Eng.Sun.COM>
  6. Date: 21 Mar 90 10:27:28 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 1687
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: stolcke@icsib12.Berkeley.EDU (Andreas Stolcke)
  12. Posting-number: Volume 6, Issue 38
  13. Archive-name: xnetld/patch1
  14.  
  15. [ xnetload has appeared in this newsgroup before, but not the R4 version.
  16.   this patch brings the R4 version up to date, but can't be applied to
  17.   the previous version, so we're resetting to patch 1 (I guess)  --dan ]
  18.  
  19.  
  20. The following is a patch to xnetload, patchlevel 0 (from the R4 distribution).
  21. It allows the Sun RPC mechanism to be used to get the load from remote
  22. machines, instead of the rwho database.
  23.  
  24. The patch contains a README file, a patch to be applied to the original
  25. xnetload source, and a copy of the R3 Load widget, which is required
  26. for compilation under R4, but wasn't included in the original distribution.
  27.  
  28. This patch is not official, but its posting was suggested by the original
  29. author, J. Michael Berkley <jmberkey@watnow.waterloo.edu>.  It will probably
  30. be incorporated in a future update, not to expected too soon, according to
  31. the author.
  32.  
  33. Have fun!
  34.  
  35. Andreas
  36.  
  37. #!/bin/sh
  38. # This is a shell archive, meaning:
  39. # 1. Remove everything above the #!/bin/sh line.
  40. # 2. Save the resulting text in a file.
  41. # 3. Execute the file with /bin/sh (not csh) to create the files:
  42. #    README.RUPRPC
  43. #    RUPRPC.patch
  44. #    X11/Load.c
  45. #    X11/Load.c.dist
  46. #    X11/Load.h
  47. #    X11/LoadP.h
  48. # This archive created: Mon Mar 19 17:07:43 1990
  49. export PATH; PATH=/bin:$PATH
  50. if test -f 'README.RUPRPC'
  51. then
  52.     echo shar: over-writing existing file "'README.RUPRPC'"
  53. fi
  54. cat << \SHAR_EOF > 'README.RUPRPC'
  55.  
  56. Changes to xnetload to use rup-like RPC for remote load:
  57. =====================================================a=
  58.  
  59. By defining RUPRPC at compile time the getload function uses Sun's RPC
  60. mechanism to obtain remote loads from rstatd(8). This is likely to be the
  61. better alternative on systems where this service is available, since rwhod(8)
  62. may have prohibitive impact on network load and is not run at
  63. many sites for this reason.
  64.  
  65. Patches:
  66.  
  67. getload.c:
  68.  
  69.     With RUPRPC defined, getload uses a simple callrpc(). The details
  70.     of the mechanism are gleaned from the rup(1) source.
  71.     Note that xnetload expects getload to return the load value in
  72.     rwhod format, hence the actual load value is multiplied by 100
  73.     and truncated to a integer.
  74.  
  75. xnetload.c:
  76.  
  77.     Allow defining DEFREMUPDATE in the Makefile.
  78.  
  79. Imakefile:
  80.  
  81.     When compiling on Suns, the RPC-based remote load mechanism is
  82.     enabled and the default update interval set to 5 seconds (same as
  83.     for local load).
  84.  
  85.     A little recursive-make hack ensures that getload.c is compiled with
  86.     Sun's cc compiler. gcc doesn't like some of the syntax in
  87.     header files in /usr/include/rpc and /usr/include/rpcsvc.
  88.     The CCOPTIONS definition in the recursive call to make may have to
  89.     be patched to match the CCOPTIONS used for gcc (e.g., put in
  90.     -f68881 if gcc uses -m68881).
  91.  
  92.     The old X11R3 Load widget code and header files are in subdirectory
  93.     X11, and the Imakefile takes that into account.
  94.  
  95. Bugs:
  96.     Still uses R3 Load widget.
  97.  
  98.     The callrpc() function used to perform the RPC does not allow
  99.     timeout specification.  So when a machine is down or not running
  100.     rstatd, xnetload will discover that only after a delay of several
  101.     (tens of) seconds.  When monitoring more than one machine,
  102.     all the displays will be slowed down by this delay.
  103.  
  104.                     Andreas Stolcke
  105.                     stolcke@icsi.berkeley.edu
  106.                     2/21/90
  107.  
  108. SHAR_EOF
  109. if test -f 'RUPRPC.patch'
  110. then
  111.     echo shar: over-writing existing file "'RUPRPC.patch'"
  112. fi
  113. cat << \SHAR_EOF > 'RUPRPC.patch'
  114. *** Imakefile.dist    Tue Oct 10 08:06:25 1989
  115. --- Imakefile    Wed Feb 21 12:27:04 1990
  116. ***************
  117. *** 22,47 ****
  118.   # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  119.   #
  120.   
  121.   #
  122.   # Since xnetload finds the local machine's load using the standard Load
  123.   # widget stuff, it needs to be able to read kmem, i.e.  setgid kmem.  If
  124.   # you do not want this, then define NOLOCAL
  125. ! #        DEFINES = -O -DNOLOCAL
  126.   
  127. !        INCLUDES = -I$(TOP) -I$(TOP)/X11
  128.   
  129.   # Dynix doesn't have -L option on load, but I have left changing the
  130.   # XLIB specification up to individual sites.  Dynix and our Sun 3.5
  131.   # don't come with a memcpy, so you'll have to add in whichever library
  132.   # has memcpy.
  133. ! /* LOCAL_LIBRARIES = $(XAWLIB) $(XMULIB) $(XTOOLLIB) $(XLIB) */
  134. ! LOCAL_LIBRARIES = -L/usr/software/X11/lib -lXaw -lXmu -lXt -lX11
  135.   
  136. !            SRCS = xnetload.c getload.o
  137. !            OBJS = xnetload.o getload.o
  138.   
  139.      INSTALLFLAGS = $(INSTKMEMFLAGS)
  140.   
  141. ! all: xnetload
  142.   
  143. ! SingleProgramTarget(xnetload,$(OBJS),,$(LOCAL_LIBRARIES))
  144. --- 22,63 ----
  145.   # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  146.   #
  147.   
  148. +      COMPATFLAGS = -DXAW_BC
  149. + 
  150.   #
  151.   # Since xnetload finds the local machine's load using the standard Load
  152.   # widget stuff, it needs to be able to read kmem, i.e.  setgid kmem.  If
  153.   # you do not want this, then define NOLOCAL
  154. ! #if SunOSPlatform
  155. !       RUPDEFINES = -DRUPRPC -DDEFREMUPDATE=5 /* -DDEBUGGING */
  156. !    SYS_LIBRARIES = -lrpcsvc
  157. ! #endif
  158. !          DEFINES = /* -DNOLOCAL */ $(RUPDEFINES)
  159.   
  160. ! #       INCLUDES = -I$(TOP) -I$(TOP)/X11
  161.   
  162.   # Dynix doesn't have -L option on load, but I have left changing the
  163.   # XLIB specification up to individual sites.  Dynix and our Sun 3.5
  164.   # don't come with a memcpy, so you'll have to add in whichever library
  165.   # has memcpy.
  166. ! LOCAL_LIBRARIES = $(XAWLIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
  167.   
  168. !            SRCS = xnetload.c getload.c X11/Load.c
  169. !            OBJS = xnetload.o getload.o Load.o
  170.   
  171.      INSTALLFLAGS = $(INSTKMEMFLAGS)
  172.   
  173. ! ComplexProgramTarget(xnetload)
  174.   
  175. ! Load.o:        X11/Load.c
  176. !         $(CC) -c $(CFLAGS) X11/Load.c
  177. ! 
  178. ! #if SunOSPlatform
  179. ! #if HasGcc    /* GCC is too picky about syntax in Sun RPC header files */
  180. ! getload.o:    getload.c
  181. !         @if [ "$(CC)" != cc ] ;\
  182. !         then $(MAKE) CC=cc CCOPTIONS= getload.o ;\
  183. !         else cmd="$(CC) -c $(CFLAGS) getload.c"; echo $$cmd; $$cmd ;\
  184. !         fi
  185. ! #endif
  186. ! #endif
  187. *** getload.c.dist    Tue Oct 10 08:06:26 1989
  188. --- getload.c    Wed Feb 21 13:21:55 1990
  189. ***************
  190. *** 32,37 ****
  191. --- 32,87 ----
  192.   #include <sys/types.h>
  193.   #include <sys/time.h>
  194.   
  195. + #ifdef RUPRPC
  196. + #include <sys/param.h>
  197. + #include <sys/stat.h>
  198. + #include <sys/socket.h>
  199. + #include <rpcsvc/rstat.h>
  200. + #include <rpc/rpc.h>
  201. + #include <rpc/pmap_clnt.h>
  202. + 
  203. + int
  204. + getload(host)
  205. +     char *host;
  206. + {
  207. +     enum clnt_stat err;
  208. +     struct statstime sw;
  209. +     
  210. + #ifdef DEBUGGING
  211. +     fprintf(stderr, "xnetload: %s: ", host);
  212. +     fflush(stderr);
  213. + #endif
  214. +     err = (enum clnt_stat)callrpc(host, RSTATPROG, RSTATVERS_TIME,
  215. +         RSTATPROC_STATS, xdr_void, 0, xdr_statstime, &sw);
  216. +     if (err != RPC_SUCCESS)
  217. +          if (err == RPC_PROGVERSMISMATCH) {
  218. +         if (err = (enum clnt_stat)callrpc(host, RSTATPROG,
  219. +             RSTATVERS_SWTCH, RSTATPROC_STATS, xdr_void, 0,
  220. +             xdr_statsswtch, &sw)) {
  221. + #ifndef DEBUGGING
  222. +             fprintf(stderr, "xnetload: %s: ", host);
  223. + #endif
  224. +             clnt_perrno(err);
  225. +             fprintf(stderr, "\n");
  226. +             return( -1 );
  227. +         }
  228. +     }
  229. +     else {
  230. + #ifndef DEBUGGING
  231. +         fprintf(stderr, "xnetload: %s: ", host);
  232. + #endif
  233. +         clnt_perrno(err);
  234. +         fprintf(stderr, "\n");
  235. +         return( -1 );
  236. +     }
  237. + 
  238. + #ifdef DEBUGGING
  239. +     fprintf(stderr, "%lf\n", (double)sw.avenrun[0]/FSCALE);
  240. + #endif
  241. +     return( (double)sw.avenrun[0]/FSCALE * 100.0);
  242. + }
  243. + 
  244. + #else /* no RUPRPC */
  245.   /* Dynix doesn't have an rwhod.h file, so here's the struct for that system */
  246.   #ifdef sequent
  247.   struct  outmp {
  248. ***************
  249. *** 113,115 ****
  250. --- 163,166 ----
  251.       }
  252.       return(0);        /* couldn't read load if here */
  253.   }
  254. + #endif
  255. SHAR_EOF
  256. if test -f 'X11/Load.c'
  257. then
  258.     echo shar: over-writing existing file "'X11/Load.c'"
  259. fi
  260. cat << \SHAR_EOF > 'X11/Load.c'
  261. #ifndef lint
  262. static char Xrcsid[] = "$XConsortium: Load.c,v 1.44 88/10/17 15:11:38 jim Exp $";
  263. #endif
  264.  
  265. /***********************************************************
  266. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  267. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  268.  
  269.                         All Rights Reserved
  270.  
  271. Permission to use, copy, modify, and distribute this software and its 
  272. documentation for any purpose and without fee is hereby granted, 
  273. provided that the above copyright notice appear in all copies and that
  274. both that copyright notice and this permission notice appear in 
  275. supporting documentation, and that the names of Digital or MIT not be
  276. used in advertising or publicity pertaining to distribution of the
  277. software without specific, written prior permission.  
  278.  
  279. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  280. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  281. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  282. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  283. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  284. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  285. SOFTWARE.
  286.  
  287. ******************************************************************/
  288.  
  289. #ifdef apollo
  290. #include "/sys/ins/base.ins.c"
  291. #include "/sys/ins/time.ins.c"
  292. typedef struct {
  293.     short        proc2_$state_t; /* ready, waiting, etc. */
  294.     pinteger    usr;        /* user sr */
  295.     linteger    upc;        /* user pc */
  296.     linteger    usp;        /* user stack pointer */
  297.     linteger    usb;        /* user sb ptr (A6) */
  298.     time_$clock_t    cpu_total;    /* cumulative cpu used by process */
  299.     unsigned short    priority;    /* process priority */
  300.     } proc1_$info_t;
  301.  
  302. std_$call void proc1_$get_cput();
  303. std_$call void proc1_$get_info();
  304. #endif /* apollo */
  305.  
  306. #include <X11/IntrinsicP.h>
  307. #include <X11/Xos.h>
  308. #include <X11/StringDefs.h>
  309. #include <X11/Xmu.h>
  310. #include <stdio.h>
  311.  
  312. #ifndef macII
  313. #ifndef apollo
  314. #ifndef LOADSTUB
  315. #include <nlist.h>
  316. #endif /* LOADSTUB */
  317. #endif /* apollo */
  318. #endif /* macII */
  319.  
  320. #ifdef sun
  321. #include <sys/param.h>
  322. #endif
  323. #ifdef NeXT
  324. #include <sys/param.h>
  325. #endif
  326. #ifdef mips
  327. #include <sys/fixpoint.h>
  328. #endif
  329. #ifdef sequent
  330. #include <sys/vm.h>
  331. #endif /* sequent */
  332. #include <X11/LoadP.h>
  333. #ifdef macII
  334. #include <a.out.h>
  335. #include <sys/var.h>
  336. #define X_AVENRUN 0
  337. #define fxtod(i) (vec[i].high+(vec[i].low/65536.0))
  338. struct lavnum {
  339.     unsigned short high;
  340.     unsigned short low;
  341. };
  342. #endif macII
  343. #ifdef UTEK
  344. #define FSCALE    100.0
  345. #endif
  346. #ifdef sequent
  347. #define FSCALE    1000.0
  348. #endif
  349.  
  350. extern long lseek();
  351. extern void exit();
  352.  
  353. /* Private Data */
  354.  
  355. static void GetLoadPoint();
  356. static XtCallbackProc getLoadProc = GetLoadPoint;
  357.  
  358. #define offset(field) XtOffset(LoadWidget,load.field)
  359. #define goffset(field) XtOffset(Widget,core.field)
  360.  
  361. static Dimension defDim = 120;
  362. static int defInterval = 5;
  363. static int defScale = 1;
  364.  
  365. static XtResource resources[] = {
  366.     {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  367.     goffset(width), XtRDimension, (caddr_t)&defDim},
  368.     {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  369.     goffset(height), XtRDimension, (caddr_t)&defDim},
  370.     {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
  371.     goffset(background_pixel), XtRString, "White"},
  372.     {XtNupdate, XtCInterval, XtRInt, sizeof(int),
  373.         offset(update), XtRInt, (caddr_t)&defInterval},
  374.     {XtNscale, XtCScale, XtRInt, sizeof(int),
  375.         offset(scale), XtRInt, (caddr_t)&defScale},
  376.     {XtNminScale, XtCScale, XtRInt, sizeof(int),
  377.         offset(min_scale), XtRInt, (caddr_t)&defScale},
  378.     {XtNlabel, XtCLabel, XtRString, sizeof(char *),
  379.         offset(text), XtRString, NULL},
  380.     {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  381.         offset(fgpixel), XtRString, "Black"},
  382.     {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel),
  383.         offset(hipixel), XtRString, "Black"},
  384.     {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  385.         offset(font), XtRString, XtDefaultFont},
  386.     {XtNgetLoadProc, XtCCallback, XtRCallback, sizeof(caddr_t),
  387.         offset(get_load), XtRFunction, (caddr_t)&getLoadProc},
  388.     {XtNreverseVideo, XtCReverseVideo, XtRBoolean, sizeof (Boolean),
  389.     offset (reverse_video), XtRString, "FALSE"},
  390. };
  391.  
  392. #undef offset
  393. #undef goffset
  394.  
  395. static void ClassInitialize();
  396. static void Initialize(), Realize(), Destroy(), Redisplay();
  397. static Boolean SetValues();
  398. static int repaint_window();
  399.  
  400. LoadClassRec loadClassRec = {
  401.     { /* core fields */
  402.     /* superclass        */    &widgetClassRec,
  403.     /* class_name        */    "Load",
  404.     /* size            */    sizeof(LoadRec),
  405.     /* class_initialize        */    ClassInitialize,
  406.     /* class_part_initialize    */    NULL,
  407.     /* class_inited        */    FALSE,
  408.     /* initialize        */    Initialize,
  409.     /* initialize_hook        */    NULL,
  410.     /* realize            */    Realize,
  411.     /* actions            */    NULL,
  412.     /* num_actions        */    0,
  413.     /* resources        */    resources,
  414.     /* num_resources        */    XtNumber(resources),
  415.     /* xrm_class        */    NULL,
  416.     /* compress_motion        */    TRUE,
  417.     /* compress_exposure    */    TRUE,
  418.     /* compress_enterleave    */    TRUE,
  419.     /* visible_interest        */    FALSE,
  420.     /* destroy            */    Destroy,
  421.     /* resize            */    NULL,
  422.     /* expose            */    Redisplay,
  423.     /* set_values        */    SetValues,
  424.     /* set_values_hook        */    NULL,
  425.     /* set_values_almost    */    NULL,
  426.     /* get_values_hook        */    NULL,
  427.     /* accept_focus        */    NULL,
  428.     /* version            */    XtVersion,
  429.     /* callback_private        */    NULL,
  430.     /* tm_table            */    NULL,
  431.     /* query_geometry        */    XtInheritQueryGeometry,
  432.     /* display_accelerator    */    XtInheritDisplayAccelerator,
  433.     /* extension        */    NULL
  434.     }
  435. };
  436.  
  437. WidgetClass loadWidgetClass = (WidgetClass) &loadClassRec;
  438.  
  439. /****************************************************************
  440.  *
  441.  * Private Procedures
  442.  *
  443.  ****************************************************************/
  444.  
  445. static void draw_it();
  446.  
  447. static void ClassInitialize()
  448. {
  449.     XtAddConverter( XtRFunction, XtRCallback, XmuCvtFunctionToCallback,
  450.             NULL, 0 );
  451. }
  452.  
  453. /* ARGSUSED */
  454. static void Initialize (greq, gnew)
  455.     Widget greq, gnew;
  456. {
  457.     LoadWidget w = (LoadWidget)gnew;
  458.     XtGCMask    valuemask;
  459.     XGCValues    myXGCV;
  460.  
  461.     /*
  462.      * set the colors if reverse video; these are the colors used:
  463.      *
  464.      *     background - paper        white
  465.      *     foreground - text, ticks    black
  466.      *     border - border        black (foreground)
  467.      *
  468.      * This doesn't completely work since the parent has already made up a 
  469.      * border.  Sigh.
  470.      */
  471.     if (w->load.reverse_video) {
  472.     Pixel fg = w->load.fgpixel;
  473.     Pixel bg = w->core.background_pixel;
  474.  
  475.     if (w->core.border_pixel == fg) w->core.border_pixel = bg;
  476.     if (w->load.hipixel == w->load.fgpixel) w->load.hipixel = bg;
  477.     w->load.fgpixel = bg;
  478.     w->core.background_pixel = fg;
  479.     }
  480.  
  481.     valuemask = GCForeground | GCBackground;
  482.     myXGCV.foreground = w->load.fgpixel;
  483.     if (w->load.font) {
  484.       myXGCV.font = w->load.font->fid;
  485.       valuemask |= GCFont;
  486.     }
  487.     myXGCV.background = w->core.background_pixel;
  488.     w->load.fgGC = XtGetGC(gnew, valuemask, &myXGCV);
  489.     myXGCV.foreground = w->load.hipixel;
  490.     w->load.hiGC = XtGetGC(gnew, valuemask, &myXGCV);
  491.  
  492.     /*
  493.      * Note that the second argument is a GCid -- QueryFont accepts a GCid and
  494.      * returns the curently contained font.
  495.      */
  496.     if (w->load.font == NULL)
  497.       w->load.font = XQueryFont (XtDisplay (w),
  498.                   XGContextFromGC (DefaultGCOfScreen (XtScreen (w))));
  499.  
  500.     if (w->load.update > 0)
  501.         w->load.interval_id =
  502.         XtAddTimeOut(w->load.update*1000, draw_it, (caddr_t)gnew);
  503.     else
  504.         w->load.interval_id = 0;
  505.  
  506.     w->load.interval = 0;
  507.     w->load.max_value = 0.0;
  508. }
  509.  
  510. static void Realize (gw, valueMask, attrs)
  511.      Widget gw;
  512.      XtValueMask *valueMask;
  513.      XSetWindowAttributes *attrs;
  514. {
  515.      XtCreateWindow( gw, (unsigned)InputOutput, (Visual *)CopyFromParent,
  516.              *valueMask, attrs );
  517. }
  518.  
  519. static void Destroy (gw)
  520.      Widget gw;
  521. {
  522.      LoadWidget w = (LoadWidget)gw;
  523.      if (w->load.interval_id) XtRemoveTimeOut (w->load.interval_id);
  524.      XtDestroyGC (w->load.fgGC);
  525.      XtDestroyGC (w->load.hiGC);
  526. }
  527.  
  528. /* ARGSUSED */
  529. static void Redisplay(gw, event, region)
  530.      Widget gw;
  531.      XEvent *event;
  532.      Region region;
  533. {
  534.      (void) repaint_window ((LoadWidget)gw, event->xexpose.x,
  535.                 event->xexpose.width);
  536. }
  537.  
  538. /* ARGSUSED */
  539. static void draw_it(client_data, id)
  540.      caddr_t client_data;
  541.      XtIntervalId id;        /* unused */
  542. {
  543.         LoadWidget w = (LoadWidget)client_data;
  544.     double value;
  545.  
  546.     if (w->load.update > 0)
  547.         w->load.interval_id =
  548.         XtAddTimeOut(w->load.update*1000, draw_it, (caddr_t)w);
  549.  
  550.     if (w->load.interval >= w->core.width) {
  551.         XClearWindow(XtDisplay(w), XtWindow(w));
  552.         w->load.interval = repaint_window(w, 0, w->core.width);
  553.     }
  554.  
  555.     /* Get the value, stash the point and draw corresponding line. */
  556.  
  557.     XtCallCallbacks( (Widget)w, XtNgetLoadProc, (caddr_t)&value );
  558.  
  559.     /* Keep w->load.max_value up to date, and if this data point is off the
  560.        graph, change the scale to make it fit. */
  561.     if (value > w->load.max_value) {
  562.         w->load.max_value = value;
  563.         if (w->load.max_value > w->load.scale) {
  564.         w->load.scale = ((int)w->load.max_value) + 1;
  565.         XClearWindow(XtDisplay(w), XtWindow(w));
  566.         w->load.interval = repaint_window(w, 0, w->core.width);
  567.         }
  568.     }
  569.  
  570.     w->load.valuedata[w->load.interval] = value;
  571.     if (XtIsRealized((Widget)w)) {
  572.         XDrawLine(XtDisplay(w), XtWindow(w), w->load.fgGC,
  573.           w->load.interval, w->core.height, w->load.interval, 
  574.             (int)(w->core.height - (w->core.height * value)
  575. /w->load.scale));
  576.         XFlush(XtDisplay(w));            /* Flush output buffers */
  577.     }
  578.     w->load.interval++;            /* Next point */
  579. } /* draw_it */
  580.  
  581. /* Blts data according to current size, then redraws the load average window.
  582.  * Next represents the number of valid points in data.  Returns the (possibly)
  583.  * adjusted value of next.  If next is 0, this routine draws an empty window
  584.  * (scale - 1 lines for graph).  If next is less than the current window width,
  585.  * the returned value is identical to the initial value of next and data is
  586.  * unchanged.  Otherwise keeps half a window's worth of data.  If data is
  587.  * changed, then w->load.max_value is updated to reflect the largest data point.
  588.  */
  589.  
  590. static int repaint_window(w, left, width)
  591.     LoadWidget w;
  592.     int left, width;
  593. {
  594.     register int i, j;
  595.     register int next = w->load.interval;
  596.     int scale = w->load.scale;
  597.     extern void bcopy();
  598.  
  599.     if (next >= w->core.width) {
  600.     j = w->core.width >> 1;
  601.     bcopy((char *)(w->load.valuedata + next - j),
  602.           (char *)(w->load.valuedata), j * sizeof(double));
  603.     next = j;
  604.     /* Since we just lost some data, recompute the w->load.max_value. */
  605.     w->load.max_value = 0.0;
  606.     for (i = 0; i < next; i++) {
  607.         if (w->load.valuedata[i] > w->load.max_value) 
  608.           w->load.max_value = w->load.valuedata[i];
  609.     }
  610.     left = 0;
  611.     width = next; 
  612.     }
  613.  
  614.     /* Compute the minimum scale required to graph the data, but don't go
  615.        lower than min_scale. */
  616.     if (w->load.interval != 0 || scale <= (int)w->load.max_value)
  617.       scale = ((int) (w->load.max_value)) + 1;
  618.     if (scale < w->load.min_scale)
  619.       scale = w->load.min_scale;
  620.     if (scale != w->load.scale) {
  621.       w->load.scale = scale;
  622.       left = 0;
  623.       width = next;
  624.       if (XtIsRealized ((Widget) w)) {
  625.     XClearWindow (XtDisplay (w), XtWindow (w));
  626.       }
  627.     }
  628.  
  629.     if (XtIsRealized((Widget)w)) {
  630.     Display *dpy = XtDisplay(w);
  631.     Window win = XtWindow(w);
  632.  
  633.     if (w->load.text) {
  634.         /* Print hostname */
  635.         XDrawString(dpy, win, w->load.hiGC, 2, 
  636.              2 + w->load.font->ascent, w->load.text, strlen(w->load.text));
  637.     }
  638.  
  639.     /* Draw graph reference lines */
  640.     for (i = 1; i < w->load.scale; i++) {
  641.         j = (i * w->core.height) / w->load.scale;
  642.         XDrawLine(dpy, win, w->load.hiGC, 0, j,
  643.               (int)w->core.width, j);
  644.     }
  645.  
  646.     if (next < (width += left)) width = next;
  647.     /* Draw data point lines. */
  648.     for (i = left; i < width; i++)
  649.         XDrawLine(dpy, win, w->load.fgGC, i, w->core.height,
  650.           i, (int)(w->core.height-(w->load.valuedata[i] * w->core.height)
  651.               /w->load.scale));
  652.         }
  653.  
  654.     return(next);
  655. }
  656.  
  657. #if apollo
  658. /* ARGSUSED */
  659. static void GetLoadPoint( w, closure, call_data )
  660.      Widget    w;        /* unused */
  661.      caddr_t    closure;    /* unused */
  662.      caddr_t    call_data;    /* pointer to (double) return value */
  663. {
  664.      static Bool    firstTime = TRUE;
  665.      static int     lastNullCpu;
  666.      static int     lastClock;
  667.      time_$clock_t  timeNow;
  668.      double         temp;
  669.      proc1_$info_t  info;
  670.      status_$t      st;
  671.  
  672.      proc1_$get_info( (short) 2, info, st );
  673.      time_$clock( timeNow );
  674.  
  675.      if (firstTime)
  676.      {
  677.          *(double *)call_data = 1.0;
  678.          firstTime = FALSE;
  679.      }
  680.      else {
  681.          temp = info.cpu_total.low32 - lastNullCpu;
  682.          *(double *)call_data = 1.0 - temp / (timeNow.low32 - lastClock);
  683.      }
  684.  
  685.      lastClock = timeNow.low32;
  686.      lastNullCpu = info.cpu_total.low32;
  687. }
  688. #else
  689. #ifdef LOADSTUB
  690.  
  691. /* ARGSUSED */
  692. static void GetLoadPoint( w, closure, call_data )
  693.      Widget    w;        /* unused */
  694.      caddr_t    closure;    /* unused */
  695.      caddr_t    call_data;    /* pointer to (double) return value */
  696. {
  697.     *(double *)call_data = 1.0;
  698. }
  699.  
  700. #else /* LOADSTUB */
  701.  
  702. #ifndef KMEM_FILE
  703. #define KMEM_FILE "/dev/kmem"
  704. #endif
  705.  
  706. #ifndef KERNEL_FILE
  707. #ifdef CRAY
  708. #define KERNEL_FILE "/unicos"
  709. #endif /* CRAY */
  710. #ifdef hpux
  711. #define KERNEL_FILE "/hp-ux"
  712. #endif /* hpux */
  713. #ifdef macII
  714. #define KERNEL_FILE "/unix"
  715. #endif /* macII */
  716. #ifdef mips
  717. # ifdef SYSTYPE_SYSV
  718. # define KERNEL_FILE "/unix"
  719. # else
  720. # define KERNEL_FILE "/vmunix"
  721. # endif /* SYSTYPE_SYSV */
  722. #endif /* mips */
  723. #ifdef sequent
  724. #define KERNEL_FILE "/dynix"
  725. #endif /* sequent */
  726.  
  727. /*
  728.  * provide default for everyone else
  729.  */
  730. #ifndef KERNEL_FILE
  731. #define KERNEL_FILE "/vmunix"
  732. #endif /* KERNEL_FILE */
  733. #endif /* KERNEL_FILE */
  734.  
  735.  
  736. #ifndef KERNEL_LOAD_VARIABLE
  737. #ifdef CRAY
  738. #define KERNEL_LOAD_VARIABLE "avenrun"
  739. #undef n_type
  740. #define n_type n_value
  741. #endif /* CRAY */
  742. #ifdef hpux
  743. #ifdef hp9000s800
  744. #define KERNEL_LOAD_VARIABLE "avenrun"
  745. #endif /* hp9000s800 */
  746. #endif /* hpux */
  747. #ifdef mips
  748. # ifdef SYSTYPE_SYSV
  749. # define KERNEL_LOAD_VARIABLE "avenrun"
  750. # else
  751. # define KERNEL_LOAD_VARIABLE "_avenrun"
  752. # endif /* SYSTYPE_SYSV */
  753. #endif /* mips */
  754. #ifdef sequent
  755. #define KERNEL_FILE "/dynix"
  756. #endif /* sequent */
  757. /*
  758.  * provide default for everyone else
  759.  */
  760. #ifndef KERNEL_LOAD_VARIABLE
  761. #define KERNEL_LOAD_VARIABLE "_avenrun"
  762. #endif /* KERNEL_LOAD_VARIABLE */
  763. #endif /* KERNEL_LOAD_VARIABLE */
  764.  
  765. #ifdef macII
  766. static struct var v;
  767. static struct nlist nl[2];
  768. static struct lavnum vec[3];
  769. #else /* not macII */
  770. #ifdef NeXT
  771. static struct nlist namelist[] = {        /* namelist for vmunix grubbing */
  772. #define LOADAV 0
  773.     {{KERNEL_LOAD_VARIABLE}},
  774.     {{0}}
  775. };
  776. #else
  777. static struct nlist namelist[] = {        /* namelist for vmunix grubbing */
  778. #define LOADAV 0
  779.     {KERNEL_LOAD_VARIABLE},
  780.     {0}
  781. };
  782. #endif
  783. #endif /* macII */
  784.  
  785.  
  786. /* ARGSUSED */
  787. static void GetLoadPoint( w, closure, call_data )
  788.      Widget    w;        /* unused */
  789.      caddr_t    closure;    /* unused */
  790.      caddr_t    call_data;    /* pointer to (double) return value */
  791. {
  792.       double *loadavg = (double *)call_data;
  793.     static int init = 0;
  794.     static kmem;
  795.     static long loadavg_seek;
  796. #ifdef macII
  797.         extern nlist();
  798.  
  799.         if(!init)   {
  800.             int i;
  801.  
  802.             strcpy(nl[0].n_name, "avenrun");
  803.             nl[1].n_name[0] = '\0';
  804.  
  805.             kmem = open(KMEM_FILE, O_RDONLY);
  806.             if (kmem < 0) {
  807.             xload_error("cannot open", KMEM_FILE);
  808.             }
  809.  
  810.             uvar(&v);
  811.  
  812.             if (nlist( KERNEL_FILE, nl) != 0) {
  813.         xload_error("cannot get name list from", KERNEL_FILE);
  814.             }
  815.             for (i = 0; i < 2; i++) {
  816.                 nl[i].n_value = (int)nl[i].n_value - v.v_kvoffset;
  817.             }
  818.             init = 1;
  819.         }
  820. #else /* not macII */
  821.     extern void nlist();
  822.     
  823.     if(!init)   {
  824.         nlist( KERNEL_FILE, namelist);
  825.         if (namelist[LOADAV].n_type == 0){
  826.         xload_error("cannot get name list from", KERNEL_FILE);
  827.         exit(-1);
  828.         }
  829.         loadavg_seek = namelist[LOADAV].n_value;
  830. # if defined(mips) && defined(SYSTYPE_SYSV)
  831.         loadavg_seek &= 0x7fffffff;
  832. # endif /* mips && SYSTYPE_SYSV */
  833.         kmem = open(KMEM_FILE, O_RDONLY);
  834.         if (kmem < 0) xload_error("cannot open", KMEM_FILE);
  835.         init = 1;
  836.     }
  837.     
  838.  
  839.     (void) lseek(kmem, loadavg_seek, 0);
  840. #endif /* macII */
  841. #if defined(sun) || defined (UTEK) || defined(sequent) || defined(NeXT)
  842.     {
  843.         long temp;
  844.         (void) read(kmem, (char *)&temp, sizeof(long));
  845.         *loadavg = (double)temp/FSCALE;
  846.     }
  847. #else /* else not sun */
  848. # ifdef macII
  849.         {
  850.                 lseek(kmem, (long)nl[X_AVENRUN].n_value, 0);
  851.                 read(kmem, vec, 3*sizeof(struct lavnum));
  852.                 *loadavg = fxtod(0);
  853.         }
  854. # else /* else not macII */
  855. #  ifdef mips
  856.     {
  857.         fix temp;
  858.         (void) read(kmem, (char *)&temp, sizeof(fix));
  859.         *loadavg = FIX_TO_DBL(temp);
  860.     }
  861. #  else /* not mips */
  862.     (void) read(kmem, (char *)loadavg, sizeof(double));
  863. #  endif /* mips */
  864. # endif /* macII */
  865. #endif /* sun */
  866.     return;
  867. }
  868. #endif /* LOADSTUB */
  869. #endif /* apollo */
  870.  
  871. static xload_error(str1, str2)
  872. char *str1, *str2;
  873. {
  874.     (void) fprintf(stderr,"xload: %s %s\n", str1, str2);
  875.     exit(-1);
  876. }
  877.  
  878. /* ARGSUSED */
  879. static Boolean SetValues (current, request, new)
  880.     Widget current, request, new;
  881. {
  882.     LoadWidget old = (LoadWidget)current;
  883.     LoadWidget w = (LoadWidget)new;
  884.     if (w->load.update != old->load.update) {
  885.     XtRemoveTimeOut (old->load.interval_id);
  886.     w->load.interval_id =
  887.         XtAddTimeOut(w->load.update*1000, draw_it, (caddr_t)w);
  888.     }
  889.  
  890.     return( FALSE );
  891. }
  892. SHAR_EOF
  893. if test -f 'X11/Load.c.dist'
  894. then
  895.     echo shar: over-writing existing file "'X11/Load.c.dist'"
  896. fi
  897. cat << \SHAR_EOF > 'X11/Load.c.dist'
  898. #ifndef lint
  899. static char Xrcsid[] = "$XConsortium: Load.c,v 1.44 88/10/17 15:11:38 jim Exp $";
  900. #endif
  901.  
  902. /***********************************************************
  903. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  904. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  905.  
  906.                         All Rights Reserved
  907.  
  908. Permission to use, copy, modify, and distribute this software and its 
  909. documentation for any purpose and without fee is hereby granted, 
  910. provided that the above copyright notice appear in all copies and that
  911. both that copyright notice and this permission notice appear in 
  912. supporting documentation, and that the names of Digital or MIT not be
  913. used in advertising or publicity pertaining to distribution of the
  914. software without specific, written prior permission.  
  915.  
  916. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  917. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  918. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  919. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  920. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  921. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  922. SOFTWARE.
  923.  
  924. ******************************************************************/
  925.  
  926. #ifdef apollo
  927. #include "/sys/ins/base.ins.c"
  928. #include "/sys/ins/time.ins.c"
  929. typedef struct {
  930.     short        proc2_$state_t; /* ready, waiting, etc. */
  931.     pinteger    usr;        /* user sr */
  932.     linteger    upc;        /* user pc */
  933.     linteger    usp;        /* user stack pointer */
  934.     linteger    usb;        /* user sb ptr (A6) */
  935.     time_$clock_t    cpu_total;    /* cumulative cpu used by process */
  936.     unsigned short    priority;    /* process priority */
  937.     } proc1_$info_t;
  938.  
  939. std_$call void proc1_$get_cput();
  940. std_$call void proc1_$get_info();
  941. #endif /* apollo */
  942.  
  943. #include <X11/IntrinsicP.h>
  944. #include <X11/Xos.h>
  945. #include <X11/StringDefs.h>
  946. #include <X11/Xmu.h>
  947. #include <stdio.h>
  948.  
  949. #ifndef macII
  950. #ifndef apollo
  951. #ifndef LOADSTUB
  952. #include <nlist.h>
  953. #endif /* LOADSTUB */
  954. #endif /* apollo */
  955. #endif /* macII */
  956.  
  957. #ifdef sun
  958. #include <sys/param.h>
  959. #endif
  960. #ifdef mips
  961. #include <sys/fixpoint.h>
  962. #endif
  963. #ifdef sequent
  964. #include <sys/vm.h>
  965. #endif /* sequent */
  966. #include <X11/LoadP.h>
  967. #ifdef macII
  968. #include <a.out.h>
  969. #include <sys/var.h>
  970. #define X_AVENRUN 0
  971. #define fxtod(i) (vec[i].high+(vec[i].low/65536.0))
  972. struct lavnum {
  973.     unsigned short high;
  974.     unsigned short low;
  975. };
  976. #endif macII
  977. #ifdef UTEK
  978. #define FSCALE    100.0
  979. #endif
  980. #ifdef sequent
  981. #define FSCALE    1000.0
  982. #endif
  983.  
  984. extern long lseek();
  985. extern void exit();
  986.  
  987. /* Private Data */
  988.  
  989. static void GetLoadPoint();
  990. static XtCallbackProc getLoadProc = GetLoadPoint;
  991.  
  992. #define offset(field) XtOffset(LoadWidget,load.field)
  993. #define goffset(field) XtOffset(Widget,core.field)
  994.  
  995. static Dimension defDim = 120;
  996. static int defInterval = 5;
  997. static int defScale = 1;
  998.  
  999. static XtResource resources[] = {
  1000.     {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  1001.     goffset(width), XtRDimension, (caddr_t)&defDim},
  1002.     {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  1003.     goffset(height), XtRDimension, (caddr_t)&defDim},
  1004.     {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
  1005.     goffset(background_pixel), XtRString, "White"},
  1006.     {XtNupdate, XtCInterval, XtRInt, sizeof(int),
  1007.         offset(update), XtRInt, (caddr_t)&defInterval},
  1008.     {XtNscale, XtCScale, XtRInt, sizeof(int),
  1009.         offset(scale), XtRInt, (caddr_t)&defScale},
  1010.     {XtNminScale, XtCScale, XtRInt, sizeof(int),
  1011.         offset(min_scale), XtRInt, (caddr_t)&defScale},
  1012.     {XtNlabel, XtCLabel, XtRString, sizeof(char *),
  1013.         offset(text), XtRString, NULL},
  1014.     {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  1015.         offset(fgpixel), XtRString, "Black"},
  1016.     {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel),
  1017.         offset(hipixel), XtRString, "Black"},
  1018.     {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  1019.         offset(font), XtRString, XtDefaultFont},
  1020.     {XtNgetLoadProc, XtCCallback, XtRCallback, sizeof(caddr_t),
  1021.         offset(get_load), XtRFunction, (caddr_t)&getLoadProc},
  1022.     {XtNreverseVideo, XtCReverseVideo, XtRBoolean, sizeof (Boolean),
  1023.     offset (reverse_video), XtRString, "FALSE"},
  1024. };
  1025.  
  1026. #undef offset
  1027. #undef goffset
  1028.  
  1029. static void ClassInitialize();
  1030. static void Initialize(), Realize(), Destroy(), Redisplay();
  1031. static Boolean SetValues();
  1032. static int repaint_window();
  1033.  
  1034. LoadClassRec loadClassRec = {
  1035.     { /* core fields */
  1036.     /* superclass        */    &widgetClassRec,
  1037.     /* class_name        */    "Load",
  1038.     /* size            */    sizeof(LoadRec),
  1039.     /* class_initialize        */    ClassInitialize,
  1040.     /* class_part_initialize    */    NULL,
  1041.     /* class_inited        */    FALSE,
  1042.     /* initialize        */    Initialize,
  1043.     /* initialize_hook        */    NULL,
  1044.     /* realize            */    Realize,
  1045.     /* actions            */    NULL,
  1046.     /* num_actions        */    0,
  1047.     /* resources        */    resources,
  1048.     /* num_resources        */    XtNumber(resources),
  1049.     /* xrm_class        */    NULL,
  1050.     /* compress_motion        */    TRUE,
  1051.     /* compress_exposure    */    TRUE,
  1052.     /* compress_enterleave    */    TRUE,
  1053.     /* visible_interest        */    FALSE,
  1054.     /* destroy            */    Destroy,
  1055.     /* resize            */    NULL,
  1056.     /* expose            */    Redisplay,
  1057.     /* set_values        */    SetValues,
  1058.     /* set_values_hook        */    NULL,
  1059.     /* set_values_almost    */    NULL,
  1060.     /* get_values_hook        */    NULL,
  1061.     /* accept_focus        */    NULL,
  1062.     /* version            */    XtVersion,
  1063.     /* callback_private        */    NULL,
  1064.     /* tm_table            */    NULL,
  1065.     /* query_geometry        */    XtInheritQueryGeometry,
  1066.     /* display_accelerator    */    XtInheritDisplayAccelerator,
  1067.     /* extension        */    NULL
  1068.     }
  1069. };
  1070.  
  1071. WidgetClass loadWidgetClass = (WidgetClass) &loadClassRec;
  1072.  
  1073. /****************************************************************
  1074.  *
  1075.  * Private Procedures
  1076.  *
  1077.  ****************************************************************/
  1078.  
  1079. static void draw_it();
  1080.  
  1081. static void ClassInitialize()
  1082. {
  1083.     XtAddConverter( XtRFunction, XtRCallback, XmuCvtFunctionToCallback,
  1084.             NULL, 0 );
  1085. }
  1086.  
  1087. /* ARGSUSED */
  1088. static void Initialize (greq, gnew)
  1089.     Widget greq, gnew;
  1090. {
  1091.     LoadWidget w = (LoadWidget)gnew;
  1092.     XtGCMask    valuemask;
  1093.     XGCValues    myXGCV;
  1094.  
  1095.     /*
  1096.      * set the colors if reverse video; these are the colors used:
  1097.      *
  1098.      *     background - paper        white
  1099.      *     foreground - text, ticks    black
  1100.      *     border - border        black (foreground)
  1101.      *
  1102.      * This doesn't completely work since the parent has already made up a 
  1103.      * border.  Sigh.
  1104.      */
  1105.     if (w->load.reverse_video) {
  1106.     Pixel fg = w->load.fgpixel;
  1107.     Pixel bg = w->core.background_pixel;
  1108.  
  1109.     if (w->core.border_pixel == fg) w->core.border_pixel = bg;
  1110.     if (w->load.hipixel == w->load.fgpixel) w->load.hipixel = bg;
  1111.     w->load.fgpixel = bg;
  1112.     w->core.background_pixel = fg;
  1113.     }
  1114.  
  1115.     valuemask = GCForeground | GCBackground;
  1116.     myXGCV.foreground = w->load.fgpixel;
  1117.     if (w->load.font) {
  1118.       myXGCV.font = w->load.font->fid;
  1119.       valuemask |= GCFont;
  1120.     }
  1121.     myXGCV.background = w->core.background_pixel;
  1122.     w->load.fgGC = XtGetGC(gnew, valuemask, &myXGCV);
  1123.     myXGCV.foreground = w->load.hipixel;
  1124.     w->load.hiGC = XtGetGC(gnew, valuemask, &myXGCV);
  1125.  
  1126.     /*
  1127.      * Note that the second argument is a GCid -- QueryFont accepts a GCid and
  1128.      * returns the curently contained font.
  1129.      */
  1130.     if (w->load.font == NULL)
  1131.       w->load.font = XQueryFont (XtDisplay (w),
  1132.                   XGContextFromGC (DefaultGCOfScreen (XtScreen (w))));
  1133.  
  1134.     if (w->load.update > 0)
  1135.         w->load.interval_id =
  1136.         XtAddTimeOut(w->load.update*1000, draw_it, (caddr_t)gnew);
  1137.     else
  1138.         w->load.interval_id = 0;
  1139.  
  1140.     w->load.interval = 0;
  1141.     w->load.max_value = 0.0;
  1142. }
  1143.  
  1144. static void Realize (gw, valueMask, attrs)
  1145.      Widget gw;
  1146.      XtValueMask *valueMask;
  1147.      XSetWindowAttributes *attrs;
  1148. {
  1149.      XtCreateWindow( gw, (unsigned)InputOutput, (Visual *)CopyFromParent,
  1150.              *valueMask, attrs );
  1151. }
  1152.  
  1153. static void Destroy (gw)
  1154.      Widget gw;
  1155. {
  1156.      LoadWidget w = (LoadWidget)gw;
  1157.      if (w->load.interval_id) XtRemoveTimeOut (w->load.interval_id);
  1158.      XtDestroyGC (w->load.fgGC);
  1159.      XtDestroyGC (w->load.hiGC);
  1160. }
  1161.  
  1162. /* ARGSUSED */
  1163. static void Redisplay(gw, event, region)
  1164.      Widget gw;
  1165.      XEvent *event;
  1166.      Region region;
  1167. {
  1168.      (void) repaint_window ((LoadWidget)gw, event->xexpose.x,
  1169.                 event->xexpose.width);
  1170. }
  1171.  
  1172. /* ARGSUSED */
  1173. static void draw_it(client_data, id)
  1174.      caddr_t client_data;
  1175.      XtIntervalId id;        /* unused */
  1176. {
  1177.         LoadWidget w = (LoadWidget)client_data;
  1178.     double value;
  1179.  
  1180.     if (w->load.update > 0)
  1181.         w->load.interval_id =
  1182.         XtAddTimeOut(w->load.update*1000, draw_it, (caddr_t)w);
  1183.  
  1184.     if (w->load.interval >= w->core.width) {
  1185.         XClearWindow(XtDisplay(w), XtWindow(w));
  1186.         w->load.interval = repaint_window(w, 0, w->core.width);
  1187.     }
  1188.  
  1189.     /* Get the value, stash the point and draw corresponding line. */
  1190.  
  1191.     XtCallCallbacks( (Widget)w, XtNgetLoadProc, (caddr_t)&value );
  1192.  
  1193.     /* Keep w->load.max_value up to date, and if this data point is off the
  1194.        graph, change the scale to make it fit. */
  1195.     if (value > w->load.max_value) {
  1196.         w->load.max_value = value;
  1197.         if (w->load.max_value > w->load.scale) {
  1198.         w->load.scale = ((int)w->load.max_value) + 1;
  1199.         XClearWindow(XtDisplay(w), XtWindow(w));
  1200.         w->load.interval = repaint_window(w, 0, w->core.width);
  1201.         }
  1202.     }
  1203.  
  1204.     w->load.valuedata[w->load.interval] = value;
  1205.     if (XtIsRealized((Widget)w)) {
  1206.         XDrawLine(XtDisplay(w), XtWindow(w), w->load.fgGC,
  1207.           w->load.interval, w->core.height, w->load.interval, 
  1208.             (int)(w->core.height - (w->core.height * value)
  1209. /w->load.scale));
  1210.         XFlush(XtDisplay(w));            /* Flush output buffers */
  1211.     }
  1212.     w->load.interval++;            /* Next point */
  1213. } /* draw_it */
  1214.  
  1215. /* Blts data according to current size, then redraws the load average window.
  1216.  * Next represents the number of valid points in data.  Returns the (possibly)
  1217.  * adjusted value of next.  If next is 0, this routine draws an empty window
  1218.  * (scale - 1 lines for graph).  If next is less than the current window width,
  1219.  * the returned value is identical to the initial value of next and data is
  1220.  * unchanged.  Otherwise keeps half a window's worth of data.  If data is
  1221.  * changed, then w->load.max_value is updated to reflect the largest data point.
  1222.  */
  1223.  
  1224. static int repaint_window(w, left, width)
  1225.     LoadWidget w;
  1226.     int left, width;
  1227. {
  1228.     register int i, j;
  1229.     register int next = w->load.interval;
  1230.     int scale = w->load.scale;
  1231.     extern void bcopy();
  1232.  
  1233.     if (next >= w->core.width) {
  1234.     j = w->core.width >> 1;
  1235.     bcopy((char *)(w->load.valuedata + next - j),
  1236.           (char *)(w->load.valuedata), j * sizeof(double));
  1237.     next = j;
  1238.     /* Since we just lost some data, recompute the w->load.max_value. */
  1239.     w->load.max_value = 0.0;
  1240.     for (i = 0; i < next; i++) {
  1241.         if (w->load.valuedata[i] > w->load.max_value) 
  1242.           w->load.max_value = w->load.valuedata[i];
  1243.     }
  1244.     left = 0;
  1245.     width = next; 
  1246.     }
  1247.  
  1248.     /* Compute the minimum scale required to graph the data, but don't go
  1249.        lower than min_scale. */
  1250.     if (w->load.interval != 0 || scale <= (int)w->load.max_value)
  1251.       scale = ((int) (w->load.max_value)) + 1;
  1252.     if (scale < w->load.min_scale)
  1253.       scale = w->load.min_scale;
  1254.     if (scale != w->load.scale) {
  1255.       w->load.scale = scale;
  1256.       left = 0;
  1257.       width = next;
  1258.       if (XtIsRealized ((Widget) w)) {
  1259.     XClearWindow (XtDisplay (w), XtWindow (w));
  1260.       }
  1261.     }
  1262.  
  1263.     if (XtIsRealized((Widget)w)) {
  1264.     Display *dpy = XtDisplay(w);
  1265.     Window win = XtWindow(w);
  1266.  
  1267.     if (w->load.text) {
  1268.         /* Print hostname */
  1269.         XDrawString(dpy, win, w->load.hiGC, 2, 
  1270.              2 + w->load.font->ascent, w->load.text, strlen(w->load.text));
  1271.     }
  1272.  
  1273.     /* Draw graph reference lines */
  1274.     for (i = 1; i < w->load.scale; i++) {
  1275.         j = (i * w->core.height) / w->load.scale;
  1276.         XDrawLine(dpy, win, w->load.hiGC, 0, j,
  1277.               (int)w->core.width, j);
  1278.     }
  1279.  
  1280.     if (next < (width += left)) width = next;
  1281.     /* Draw data point lines. */
  1282.     for (i = left; i < width; i++)
  1283.         XDrawLine(dpy, win, w->load.fgGC, i, w->core.height,
  1284.           i, (int)(w->core.height-(w->load.valuedata[i] * w->core.height)
  1285.               /w->load.scale));
  1286.         }
  1287.  
  1288.     return(next);
  1289. }
  1290.  
  1291. #if apollo
  1292. /* ARGSUSED */
  1293. static void GetLoadPoint( w, closure, call_data )
  1294.      Widget    w;        /* unused */
  1295.      caddr_t    closure;    /* unused */
  1296.      caddr_t    call_data;    /* pointer to (double) return value */
  1297. {
  1298.      static Bool    firstTime = TRUE;
  1299.      static int     lastNullCpu;
  1300.      static int     lastClock;
  1301.      time_$clock_t  timeNow;
  1302.      double         temp;
  1303.      proc1_$info_t  info;
  1304.      status_$t      st;
  1305.  
  1306.      proc1_$get_info( (short) 2, info, st );
  1307.      time_$clock( timeNow );
  1308.  
  1309.      if (firstTime)
  1310.      {
  1311.          *(double *)call_data = 1.0;
  1312.          firstTime = FALSE;
  1313.      }
  1314.      else {
  1315.          temp = info.cpu_total.low32 - lastNullCpu;
  1316.          *(double *)call_data = 1.0 - temp / (timeNow.low32 - lastClock);
  1317.      }
  1318.  
  1319.      lastClock = timeNow.low32;
  1320.      lastNullCpu = info.cpu_total.low32;
  1321. }
  1322. #else
  1323. #ifdef LOADSTUB
  1324.  
  1325. /* ARGSUSED */
  1326. static void GetLoadPoint( w, closure, call_data )
  1327.      Widget    w;        /* unused */
  1328.      caddr_t    closure;    /* unused */
  1329.      caddr_t    call_data;    /* pointer to (double) return value */
  1330. {
  1331.     *(double *)call_data = 1.0;
  1332. }
  1333.  
  1334. #else /* LOADSTUB */
  1335.  
  1336. #ifndef KMEM_FILE
  1337. #define KMEM_FILE "/dev/kmem"
  1338. #endif
  1339.  
  1340. #ifndef KERNEL_FILE
  1341. #ifdef CRAY
  1342. #define KERNEL_FILE "/unicos"
  1343. #endif /* CRAY */
  1344. #ifdef hpux
  1345. #define KERNEL_FILE "/hp-ux"
  1346. #endif /* hpux */
  1347. #ifdef macII
  1348. #define KERNEL_FILE "/unix"
  1349. #endif /* macII */
  1350. #ifdef mips
  1351. # ifdef SYSTYPE_SYSV
  1352. # define KERNEL_FILE "/unix"
  1353. # else
  1354. # define KERNEL_FILE "/vmunix"
  1355. # endif /* SYSTYPE_SYSV */
  1356. #endif /* mips */
  1357. #ifdef sequent
  1358. #define KERNEL_FILE "/dynix"
  1359. #endif /* sequent */
  1360.  
  1361. /*
  1362.  * provide default for everyone else
  1363.  */
  1364. #ifndef KERNEL_FILE
  1365. #define KERNEL_FILE "/vmunix"
  1366. #endif /* KERNEL_FILE */
  1367. #endif /* KERNEL_FILE */
  1368.  
  1369.  
  1370. #ifndef KERNEL_LOAD_VARIABLE
  1371. #ifdef CRAY
  1372. #define KERNEL_LOAD_VARIABLE "avenrun"
  1373. #undef n_type
  1374. #define n_type n_value
  1375. #endif /* CRAY */
  1376. #ifdef hpux
  1377. #ifdef hp9000s800
  1378. #define KERNEL_LOAD_VARIABLE "avenrun"
  1379. #endif /* hp9000s800 */
  1380. #endif /* hpux */
  1381. #ifdef mips
  1382. # ifdef SYSTYPE_SYSV
  1383. # define KERNEL_LOAD_VARIABLE "avenrun"
  1384. # else
  1385. # define KERNEL_LOAD_VARIABLE "_avenrun"
  1386. # endif /* SYSTYPE_SYSV */
  1387. #endif /* mips */
  1388. #ifdef sequent
  1389. #define KERNEL_FILE "/dynix"
  1390. #endif /* sequent */
  1391. /*
  1392.  * provide default for everyone else
  1393.  */
  1394. #ifndef KERNEL_LOAD_VARIABLE
  1395. #define KERNEL_LOAD_VARIABLE "_avenrun"
  1396. #endif /* KERNEL_LOAD_VARIABLE */
  1397. #endif /* KERNEL_LOAD_VARIABLE */
  1398.  
  1399. #ifdef macII
  1400. static struct var v;
  1401. static struct nlist nl[2];
  1402. static struct lavnum vec[3];
  1403. #else /* not macII */
  1404. static struct nlist namelist[] = {        /* namelist for vmunix grubbing */
  1405. #define LOADAV 0
  1406.     {KERNEL_LOAD_VARIABLE},
  1407.     {0}
  1408. };
  1409. #endif /* macII */
  1410.  
  1411.  
  1412. /* ARGSUSED */
  1413. static void GetLoadPoint( w, closure, call_data )
  1414.      Widget    w;        /* unused */
  1415.      caddr_t    closure;    /* unused */
  1416.      caddr_t    call_data;    /* pointer to (double) return value */
  1417. {
  1418.       double *loadavg = (double *)call_data;
  1419.     static int init = 0;
  1420.     static kmem;
  1421.     static long loadavg_seek;
  1422. #ifdef macII
  1423.         extern nlist();
  1424.  
  1425.         if(!init)   {
  1426.             int i;
  1427.  
  1428.             strcpy(nl[0].n_name, "avenrun");
  1429.             nl[1].n_name[0] = '\0';
  1430.  
  1431.             kmem = open(KMEM_FILE, O_RDONLY);
  1432.             if (kmem < 0) {
  1433.             xload_error("cannot open", KMEM_FILE);
  1434.             }
  1435.  
  1436.             uvar(&v);
  1437.  
  1438.             if (nlist( KERNEL_FILE, nl) != 0) {
  1439.         xload_error("cannot get name list from", KERNEL_FILE);
  1440.             }
  1441.             for (i = 0; i < 2; i++) {
  1442.                 nl[i].n_value = (int)nl[i].n_value - v.v_kvoffset;
  1443.             }
  1444.             init = 1;
  1445.         }
  1446. #else /* not macII */
  1447.     extern void nlist();
  1448.     
  1449.     if(!init)   {
  1450.         nlist( KERNEL_FILE, namelist);
  1451.         if (namelist[LOADAV].n_type == 0){
  1452.         xload_error("cannot get name list from", KERNEL_FILE);
  1453.         exit(-1);
  1454.         }
  1455.         loadavg_seek = namelist[LOADAV].n_value;
  1456. # if defined(mips) && defined(SYSTYPE_SYSV)
  1457.         loadavg_seek &= 0x7fffffff;
  1458. # endif /* mips && SYSTYPE_SYSV */
  1459.         kmem = open(KMEM_FILE, O_RDONLY);
  1460.         if (kmem < 0) xload_error("cannot open", KMEM_FILE);
  1461.         init = 1;
  1462.     }
  1463.     
  1464.  
  1465.     (void) lseek(kmem, loadavg_seek, 0);
  1466. #endif /* macII */
  1467. #if defined(sun) || defined (UTEK) || defined(sequent)
  1468.     {
  1469.         long temp;
  1470.         (void) read(kmem, (char *)&temp, sizeof(long));
  1471.         *loadavg = (double)temp/FSCALE;
  1472.     }
  1473. #else /* else not sun */
  1474. # ifdef macII
  1475.         {
  1476.                 lseek(kmem, (long)nl[X_AVENRUN].n_value, 0);
  1477.                 read(kmem, vec, 3*sizeof(struct lavnum));
  1478.                 *loadavg = fxtod(0);
  1479.         }
  1480. # else /* else not macII */
  1481. #  ifdef mips
  1482.     {
  1483.         fix temp;
  1484.         (void) read(kmem, (char *)&temp, sizeof(fix));
  1485.         *loadavg = FIX_TO_DBL(temp);
  1486.     }
  1487. #  else /* not mips */
  1488.     (void) read(kmem, (char *)loadavg, sizeof(double));
  1489. #  endif /* mips */
  1490. # endif /* macII */
  1491. #endif /* sun */
  1492.     return;
  1493. }
  1494. #endif /* LOADSTUB */
  1495. #endif /* apollo */
  1496.  
  1497. static xload_error(str1, str2)
  1498. char *str1, *str2;
  1499. {
  1500.     (void) fprintf(stderr,"xload: %s %s\n", str1, str2);
  1501.     exit(-1);
  1502. }
  1503.  
  1504. /* ARGSUSED */
  1505. static Boolean SetValues (current, request, new)
  1506.     Widget current, request, new;
  1507. {
  1508.     LoadWidget old = (LoadWidget)current;
  1509.     LoadWidget w = (LoadWidget)new;
  1510.     if (w->load.update != old->load.update) {
  1511.     XtRemoveTimeOut (old->load.interval_id);
  1512.     w->load.interval_id =
  1513.         XtAddTimeOut(w->load.update*1000, draw_it, (caddr_t)w);
  1514.     }
  1515.  
  1516.     return( FALSE );
  1517. }
  1518. SHAR_EOF
  1519. if test -f 'X11/Load.h'
  1520. then
  1521.     echo shar: over-writing existing file "'X11/Load.h'"
  1522. fi
  1523. cat << \SHAR_EOF > 'X11/Load.h'
  1524. /*
  1525. * $XConsortium: Load.h,v 1.13 88/10/23 14:03:12 swick Exp $
  1526. */
  1527.  
  1528.  
  1529. /***********************************************************
  1530. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  1531. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  1532.  
  1533.                         All Rights Reserved
  1534.  
  1535. Permission to use, copy, modify, and distribute this software and its 
  1536. documentation for any purpose and without fee is hereby granted, 
  1537. provided that the above copyright notice appear in all copies and that
  1538. both that copyright notice and this permission notice appear in 
  1539. supporting documentation, and that the names of Digital or MIT not be
  1540. used in advertising or publicity pertaining to distribution of the
  1541. software without specific, written prior permission.  
  1542.  
  1543. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  1544. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  1545. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  1546. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  1547. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  1548. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  1549. SOFTWARE.
  1550.  
  1551. ******************************************************************/
  1552.  
  1553. #ifndef _XtLoad_h
  1554. #define _XtLoad_h
  1555.  
  1556. /***********************************************************************
  1557.  *
  1558.  * Load Widget
  1559.  *
  1560.  ***********************************************************************/
  1561.  
  1562. /* Parameters:
  1563.  
  1564.  Name             Class        RepType        Default Value
  1565.  ----             -----        -------        -------------
  1566.  background         Background        Pixel        White
  1567.  border             BorderColor    Pixel        Black
  1568.  borderWidth         BorderWidth    Dimension    1
  1569.  destroyCallback     Callback        Pointer        NULL
  1570.  font             Font        XFontStruct*    XtDefaultFont
  1571.  foreground         Foreground        Pixel        Black
  1572.  getLoadProc         Callback        Callback    (internal)
  1573.  height             Height        Dimension    120
  1574.  highlight         Foreground        Pixel        Black
  1575.  label             Label        String        (empty string)
  1576.  mappedWhenManaged   MappedWhenManaged    Boolean        True
  1577.  minScale         Scale        int        1
  1578.  reverseVideo         ReverseVideo    Boolean        False
  1579.  scale             Scale        int        1
  1580.  update             Interval        int        5 (seconds)
  1581.  width             Width        Dimension    120
  1582.  x             Position        Position    0
  1583.  y             Position        Position    0
  1584.  
  1585. */
  1586.  
  1587.  
  1588. #define XtNupdate        "update"
  1589. #define XtNscale        "scale"
  1590. #define XtNvmunix        "vmunix"
  1591. #define XtNminScale        "minScale"
  1592. #define XtNgetLoadProc        "getLoadProc"
  1593. #define XtNhighlight        "highlight"
  1594.  
  1595. #define XtCScale        "Scale"
  1596.  
  1597. typedef struct _LoadRec *LoadWidget;  /* completely defined in LoadPrivate.h */
  1598. typedef struct _LoadClassRec *LoadWidgetClass;    /* completely defined
  1599. in LoadPrivate.h */
  1600.  
  1601. extern WidgetClass loadWidgetClass;
  1602.  
  1603. #endif _XtLoad_h
  1604. /* DON'T ADD STUFF AFTER THIS #endif */
  1605. SHAR_EOF
  1606. if test -f 'X11/LoadP.h'
  1607. then
  1608.     echo shar: over-writing existing file "'X11/LoadP.h'"
  1609. fi
  1610. cat << \SHAR_EOF > 'X11/LoadP.h'
  1611. /*
  1612. * $XConsortium: LoadP.h,v 1.11 88/09/06 16:41:56 jim Exp $
  1613. */
  1614.  
  1615.  
  1616. /***********************************************************
  1617. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  1618. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  1619.  
  1620.                         All Rights Reserved
  1621.  
  1622. Permission to use, copy, modify, and distribute this software and its 
  1623. documentation for any purpose and without fee is hereby granted, 
  1624. provided that the above copyright notice appear in all copies and that
  1625. both that copyright notice and this permission notice appear in 
  1626. supporting documentation, and that the names of Digital or MIT not be
  1627. used in advertising or publicity pertaining to distribution of the
  1628. software without specific, written prior permission.  
  1629.  
  1630. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  1631. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  1632. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  1633. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  1634. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  1635. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  1636. SOFTWARE.
  1637.  
  1638. ******************************************************************/
  1639.  
  1640. #ifndef _LoadP_h
  1641. #define _LoadP_h
  1642.  
  1643. #include <X11/Load.h>
  1644. #include <X11/CoreP.h>
  1645.  
  1646. #define SEG_BUFF_SIZE        128
  1647.  
  1648. /* New fields for the load widget instance record */
  1649. typedef struct {
  1650.      Pixel    fgpixel;    /* color index for graph */
  1651.      Pixel    hipixel;    /* color index for text */
  1652.      XFontStruct    *font;    /* font for text */
  1653.      GC    fgGC;        /* graphics context for fgpixel */
  1654.      GC    hiGC;        /* graphics context for hipixel */
  1655. /* start of graph stuff */
  1656.      int    update;        /* update frequence */
  1657.      int    scale;        /* scale factor */
  1658.      int     min_scale;    /* smallest scale factor */
  1659.      int     interval;    /* data point interval */
  1660.      Boolean reverse_video;        /* display in reverse video */
  1661.      char    *text;        /* label */
  1662.      double max_value;    /* Max Value in window */
  1663.      double valuedata[2048];/* record of data points */
  1664.      XtIntervalId interval_id;
  1665.      XtCallbackList get_load; /* proc to call to fetch load pt */
  1666.    } LoadPart;
  1667.  
  1668. /* Full instance record declaration */
  1669. typedef struct _LoadRec {
  1670.    CorePart core;
  1671.    LoadPart load;
  1672.    } LoadRec;
  1673.  
  1674. /* New fields for the Load widget class record */
  1675. typedef struct {int dummy;} LoadClassPart;
  1676.  
  1677. /* Full class record declaration. */
  1678. typedef struct _LoadClassRec {
  1679.    CoreClassPart core_class;
  1680.    LoadClassPart load_class;
  1681.    } LoadClassRec;
  1682.  
  1683. /* Class pointer. */
  1684. extern LoadClassRec loadClassRec;
  1685.  
  1686. #endif _LoadP_h
  1687. SHAR_EOF
  1688. #    End of shell archive
  1689. exit 0
  1690.  
  1691. dan
  1692. -----------------------------------------------------------
  1693.             O'Reilly && Associates
  1694.         argv@sun.com / argv@ora.com
  1695.        632 Petaluma Ave, Sebastopol, CA 95472 
  1696.      800-338-NUTS, in CA: 800-533-NUTS, FAX 707-829-0104
  1697.     Opinions expressed reflect those of the author only.
  1698.